package top.itaso.lib.widget.helper;

import android.util.Log;

import java.util.ArrayList;
import java.util.List;

import top.itaso.lib.widget.vo.Node;

class NodeTreeHelper {
    private static final String TAG = "TreeHelper";

    /**
     * 传入散乱的 Node 数据集， 返回转换成树级关系后的 Node 集合
     * 拿到用户传入的数据，转化为 List<Node> 以及设置 Node 间关系，然后根节点，从根往下遍历进行排序；
     *
     * @param sourceNodes        节点数据
     * @param defaultExpandLevel
     * @return
     */
    public static List<Node> convertNodes(List<Node> sourceNodes, int defaultExpandLevel) {
        Log.d(TAG, "convertNodes: >>>>>>datas.size=" + sourceNodes.size() + ",defaultExpandLevel=" + defaultExpandLevel);
        //整合数据
        List<Node> nodes = convertData2Node(sourceNodes);
        Log.d(TAG, "convertNodes: >>>>>>nodes.size=" + nodes.size());
        // 拿到根节点
        List<Node> rootNodes = getRootNodes(nodes);
        Log.d(TAG, "convertNodes: >>>>>>rootNodes.size=" + rootNodes.size());

        List<Node> convertResult = new ArrayList<>();
        // 排序以及设置 Node 间关系
        for (Node node : rootNodes) {
            addNode(convertResult, node, defaultExpandLevel, 1);
        }
        return convertResult;
    }

    /**
     * 过滤出所有可见的 Node
     * 过滤 Node 的代码很简单，遍历所有的 Node，只要是根节点或者父节点是展开状态就添加返回
     *
     * @param sourceNodes
     * @return
     */
    public static List<Node> filterVisibleNodes(List<Node> sourceNodes) {
        List<Node> result = new ArrayList<Node>();

        for (Node node : sourceNodes) {
            if (node == null) {
                continue;
            }
            // 如果为根节点，或者上层目录为展开状态，则该节点即为可见的
            if (node.isRoot() || node.isParentExpand()) {
                setNodeIcon(node);
                result.add(node);
            }
        }
        return result;
    }

    /**
     * 将 散乱关系 的数据转化为 树型关系 的节点
     * 设置 Node 间的层级关系（即 Parent 和 Child 关系）；让每两个节点都比较一次，即可设置其中的关系
     *
     * @param sourceNodes 节点数据
     */
    private static List<Node> convertData2Node(List<Node> sourceNodes) {
        for (int i = 0; i < sourceNodes.size(); i++) {
            Node node = sourceNodes.get(i);
            for (int j = i + 1; j < sourceNodes.size(); j++) {
                Node checkNode = sourceNodes.get(j);//被校验的节点
                if (checkNode.getPid() instanceof String) {
                    if (checkNode.getPid().equals(node.getId())) {//判断 node 和 checkNode 的关系为 node 是 checkNode 的父节点关系
                        node.getChildren().add(checkNode);//设置 checkNode 为 node 的子节点
                        checkNode.setParent(node);//设置 node 为 checkNode 的父节点
                    } else if (checkNode.getId().equals(node.getPid())) {//判断 node 和 checkNode 的关系为 checkNode 是 node 的父节点关系
                        checkNode.getChildren().add(node);
                        node.setParent(checkNode);
                    }
                } else {
                    if (checkNode.getPid() == node.getId()) {
                        node.getChildren().add(checkNode);
                        checkNode.setParent(node);
                    } else if (checkNode.getId() == node.getPid()) {
                        checkNode.getChildren().add(node);
                        node.setParent(checkNode);
                    }
                }
            }
        }
        return sourceNodes;
    }

    /**
     * 提取 根节点
     *
     * @param sourceNodes 节点数据
     * @return
     */
    private static List<Node> getRootNodes(List<Node> sourceNodes) {
        List<Node> rootNodes = new ArrayList<Node>();
        for (Node node : sourceNodes) {
            if (node.isRoot()) {
                rootNodes.add(node);
            }
        }
        return rootNodes;
    }

    /**
     * 把一个节点上的所有的内容都挂上去
     * 通过 递归 的方式，把指定的 node 节点 以及指 node 节点 点下的所有树形关系的子节点 按顺序 统一 add 到 convertResult 集合中 默认展开几级树，并赋予 层级 标记
     *
     * @param convertResult
     * @param node
     * @param defaultExpandLeval 指定默认展开几级树
     * @param currentLevel
     * @param <T>
     */
    private static <T> void addNode(List<Node> convertResult, Node<T> node, int defaultExpandLeval, int currentLevel) {
        convertResult.add(node);

        if (defaultExpandLeval >= currentLevel) {
            node.setExpand(true);
        } else {

        }

        if (node.isLeaf()) {
            return;
        }
        for (int i = 0; i < node.getChildren().size(); i++) {
            addNode(convertResult, node.getChildren().get(i), defaultExpandLeval, currentLevel + 1);
        }
    }

    /**
     * 设置节点的图标
     *
     * @param node
     */
    private static void setNodeIcon(Node node) {
        if (node.isLeaf()) {
            node.setIcon(-1);
            return;
        }
        node.setIcon(node.isExpand() ? node.getIndicativeIconExpand() : node.getIndicativeIconUnExpand());
    }
}
